package org.jeecg.modules.cw.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.modules.cw.entity.CwGyjfzc;
import org.jeecg.modules.cw.entity.CwGyjfzcTj;
import org.jeecg.modules.cw.entity.CwJbszqkzb;
import org.jeecg.modules.cw.entity.CwJbszqkzbZhu;
import org.jeecg.modules.cw.mapper.CwGyjfzcMapper;
import org.jeecg.modules.cw.mapper.CwGyjfzcTjMapper;
import org.jeecg.modules.cw.service.ICwJbszqkzbService;
import org.jeecg.modules.cw.service.ICwJbszqkzbZhuService;
import org.jeecg.modules.cw.service.ICwGyjfzcTjService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.Serializable;
import java.util.Collection;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;

/**
 * @Description: 公用经费支出提交表
 * @Author: jeecg-boot
 * @Date: 2025-09-12
 * @Version: V1.0
 */
@Service
public class CwGyjfzcTjServiceImpl extends ServiceImpl<CwGyjfzcTjMapper, CwGyjfzcTj> implements ICwGyjfzcTjService {

	// 日志组件
	private static final Logger logger = LoggerFactory.getLogger(CwGyjfzcTjServiceImpl.class);

	// 依赖注入
	@Autowired
	private CwGyjfzcTjMapper cwGyjfzcTjMapper;
	@Autowired
	private CwGyjfzcMapper cwGyjfzcMapper;
	@Autowired
	private ICwJbszqkzbService cwJbszqkzbService;
	@Autowired
	private ICwJbszqkzbZhuService cwJbszqkzbZhuService;


	/**
	 * 费用类型枚举（含原有26种商品服务支出 + 新增16种资本性支出，cwPx按顺序递增）
	 * 新增字段：calculationBasis（预算依据）、cwTbsm（填表说明）、disbursementType（支出类型）
	 */
	private enum FeeType {
		// ====================== 原有：商品和服务支出（cwPx 22-47） ======================
		OFFICE_FEE("办公费", 25, "1.人员定额500元/人*人数=\n2.\n3.", "", "商品和服务支出"),
		PRINTING_FEE("印刷费", 26, "", "", "商品和服务支出"),
		SERVICE_FEE("手续费", 27, "", "", "商品和服务支出"),
		WATER_FEE("水费", 28, "", "", "商品和服务支出"),
		ELECTRICITY_FEE("电费", 29, "", "", "商品和服务支出"),
		POSTAL_FEE("邮电费", 30, "电话费  万元，网络费  万元，邮寄费  万元。", "", "商品和服务支出"),
		HEATING_FEE("取暖费", 31, "", "", "商品和服务支出"),
		PROPERTY_FEE("物业管理费", 32, "", "", "商品和服务支出"),
		TRAVEL_FEE("差旅费", 33, "", "", "商品和服务支出"),
		ABROAD_FEE("因公出国境费用", 34, "", "", "商品和服务支出"),
		MAINTENANCE_FEE("维修护费", 35, "", "", "商品和服务支出"),
		RENT_FEE("租赁费", 36, "", "", "商品和服务支出"),
		MEETING_FEE("会议费", 37, "参加会议  万元；举办会议  万元。", "", "商品和服务支出"),
		TRAINING_FEE("培训费", 38, "参加培训  万元；举办培训  万元。", "", "商品和服务支出"),
		RECEPTION_FEE("公务接待费", 39, "", "", "商品和服务支出"),
		MATERIAL_FEE("专用材料费", 40, "", "", "商品和服务支出"),
		CLOTHING_FEE("被装购置费", 41, "", "", "商品和服务支出"),
		FUEL_FEE("专用燃料费", 42, "", "", "商品和服务支出"),
		LABOR_FEE("劳务费", 43, "", "", "商品和服务支出"),
		ENTRUSTED_FEE("委托业务费", 44, "", "", "商品和服务支出"),
		UNION_FEE("工会经费", 45, "", "", "商品和服务支出"),
		VEHICLE_FEE("公务用车运行维护费", 46, "", "", "商品和服务支出"),
		OTHER_TRAFFIC_FEE("其他交通费用", 47, "", "", "商品和服务支出"),
		TAX_FEE("税金及附加费用", 48, "", "1.增值税税额=合同金额/（1+6%）*0.06；\n2、附件税（教育税金附加、地方教育税金附加、城建税）=增值税税额*（3%+2%+7%）；\n3、印花税注意查找税目（不同）", "商品和服务支出"),
		OTHER_EXPENSE("其他商品和服务支出", 49, "", "预计的上缴20%院科研发展基金不要在此填列，直接冲减当年成果转化收入", "商品和服务支出"),

		// ====================== 新增：资本性支出（cwPx 48-63，按顺序递增） ======================
		BUILDING_PURCHASE("房屋建筑物购建", 48, "", "", "资本性支出"),
		OFFICE_EQUIPMENT("办公设备购置", 49, "", "", "资本性支出"),
		SPECIAL_EQUIPMENT("专用设备购置", 50, "", "", "资本性支出"),
		INFRASTRUCTURE("基础设施建设", 51, "", "", "资本性支出"),
		LARGE_REPAIR("大型修缮", 52, "", "", "资本性支出"),
		IT_SOFTWARE("信息网络及软件购置更新", 53, "", "", "资本性支出"),
		MATERIAL_RESERVE("物资储备", 54, "", "", "资本性支出"),
		LAND_COMPENSATION("土地补偿", 55, "", "", "资本性支出"),
		RESettlement_ALLOWANCE("安置补助", 56, "", "", "资本性支出"),
		ATTACHMENT_COMPENSATION("地上附着物和青苗补偿", 57, "", "", "资本性支出"),
		DEMOLITION_COMPENSATION("拆迁补偿", 58, "", "", "资本性支出"),
		OFFICIAL_VEHICLE("公务用车购置", 59, "", "", "资本性支出"),
		OTHER_VEHICLE("其他交通工具购置", 60, "", "", "资本性支出"),
		CULTURAL_RELICS("文物和陈列品购置", 61, "", "", "资本性支出"),
		INTANGIBLE_ASSET("无形资产购置", 62, "", "", "资本性支出"),
		OTHER_CAPITAL_EXPENSE("其他资本性支出", 63, "", "", "资本性支出");

		private final String feeName;          // 费用名称（对应jjflkm字段）
		private final int cwPx;                // 排序值（对应cwPx字段，确保连续递增）
		private final String calculationBasis; // 预算依据（新增字段）
		private final String cwTbsm;           // 填表说明（新增字段）
		private final String disbursementType; // 支出类型（商品和服务支出/资本性支出）

		// 枚举构造方法：新增disbursementType参数
		FeeType(String feeName, int cwPx, String calculationBasis, String cwTbsm, String disbursementType) {
			this.feeName = feeName;
			this.cwPx = cwPx;
			this.calculationBasis = calculationBasis;
			this.cwTbsm = cwTbsm;
			this.disbursementType = disbursementType;
		}

		/**
		 * 根据费用名称匹配枚举（支持所有42种费用）
		 */
		public static FeeType getByFeeName(String feeName) {
			if (feeName == null) return null;
			for (FeeType type : FeeType.values()) {
				if (type.feeName.equals(feeName)) {
					return type;
				}
			}
			return null;
		}

		// Getter：新增disbursementType的Getter方法
		public String getFeeName() {
			return feeName;
		}

		public int getCwPx() {
			return cwPx;
		}

		public String getCalculationBasis() {
			return calculationBasis;
		}

		public String getCwTbsm() {
			return cwTbsm;
		}

		public String getDisbursementType() {
			return disbursementType;
		}
	}

	/**
	 * 费用金额封装类（存储财政金额+总金额，支持所有费用类型的累加）
	 */
	private static class FeeAmount {
		private double financial = 0.0; // 财政金额
		private double money = 0.0;     // 总金额

		/**
		 * 累加金额（空值默认按0处理，避免空指针）
		 */
		public void accumulate(Double financial, Double money) {
			this.financial += (financial == null ? 0.0 : financial);
			this.money += (money == null ? 0.0 : money);
		}

		// Getter
		public double getFinancial() {
			return financial;
		}

		public double getMoney() {
			return money;
		}
	}


	// ====================== 核心业务方法（支持42种费用，修复金额统计逻辑） ======================
	@Override
	@Transactional(rollbackFor = Exception.class)
	public void saveMain(CwGyjfzcTj cwGyjfzcTj, List<CwGyjfzc> cwGyjfzcList) {
		logger.info("开始保存公用经费支出提交表，unit：{}，year：{}，子表记录数：{}",
				cwGyjfzcTj.getUnit(), cwGyjfzcTj.getYear(), CollectionUtils.size(cwGyjfzcList));

		// 1. 获取登录用户（空指针防护）
		LoginUser loginUser = getLoginUser();
		String userId = loginUser.getId();

		// 2. 保存主表
		cwGyjfzcTj.setMainId(userId);
		cwGyjfzcTjMapper.insert(cwGyjfzcTj);
		logger.debug("主表保存成功，主表ID：{}", cwGyjfzcTj.getId());

		// 3. 获取/创建收支明细总表主表
		CwJbszqkzbZhu zhuEntity = getOrCreateJbszqkzbZhu(cwGyjfzcTj.getUnit(), cwGyjfzcTj.getYear(), userId);

		// 4. 处理当前主表的子表插入（仅插入，不单独统计）
		insertSubList(cwGyjfzcTj.getId(), cwGyjfzcList);

		// 5. 重新统计【所有同年同单位】子表的总金额，更新CwJbszqkzb（关键修复：用总和替代单表金额）
		Map<FeeType, FeeAmount> totalFeeMap = calculateTotalFeeAmounts(cwGyjfzcTj.getUnit(), cwGyjfzcTj.getYear());
		saveOrUpdateJbszqkzb(cwGyjfzcTj.getUnit(), cwGyjfzcTj.getYear(), zhuEntity.getId(), userId, totalFeeMap, false);

		logger.info("公用经费支出提交表保存完成，主表ID：{}", cwGyjfzcTj.getId());
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void updateMain(CwGyjfzcTj cwGyjfzcTj, List<CwGyjfzc> cwGyjfzcList) {
		// 主表ID校验
		if (cwGyjfzcTj.getId() == null) {
			throw new RuntimeException("主表ID为空，无法执行更新操作");
		}
		logger.info("开始更新公用经费支出提交表，主表ID：{}，unit：{}，year：{}，子表记录数：{}",
				cwGyjfzcTj.getId(), cwGyjfzcTj.getUnit(), cwGyjfzcTj.getYear(), CollectionUtils.size(cwGyjfzcList));

		// 1. 获取登录用户
		LoginUser loginUser = getLoginUser();
		String userId = loginUser.getId();

		// 2. 更新主表
		cwGyjfzcTj.setMainId(userId);
		cwGyjfzcTjMapper.updateById(cwGyjfzcTj);
		logger.debug("主表更新成功，主表ID：{}", cwGyjfzcTj.getId());

		// 3. 获取/创建收支明细总表主表
		CwJbszqkzbZhu zhuEntity = getOrCreateJbszqkzbZhu(cwGyjfzcTj.getUnit(), cwGyjfzcTj.getYear(), userId);

		// 4. 全量替换当前主表的子表（删旧插新）
		cwGyjfzcMapper.deleteByMainId(cwGyjfzcTj.getId());
		logger.debug("旧子表数据删除完成，主表ID：{}", cwGyjfzcTj.getId());
		insertSubList(cwGyjfzcTj.getId(), cwGyjfzcList); // 仅插入新子表

		// 5. 重新统计【所有同年同单位】子表的总金额，更新CwJbszqkzb（关键修复：避免覆盖单表金额）
		Map<FeeType, FeeAmount> totalFeeMap = calculateTotalFeeAmounts(cwGyjfzcTj.getUnit(), cwGyjfzcTj.getYear());
		saveOrUpdateJbszqkzb(cwGyjfzcTj.getUnit(), cwGyjfzcTj.getYear(), zhuEntity.getId(), userId, totalFeeMap, true);

		logger.info("公用经费支出提交表更新完成，主表ID：{}", cwGyjfzcTj.getId());
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void delMain(String id) {
		if (id == null || id.trim().isEmpty()) {
			throw new RuntimeException("删除ID为空，无法执行删除操作");
		}
		logger.info("开始删除公用经费支出提交表，主表ID：{}", id);

		try {
			// 1. 获取待删除主表的单位和年份（用于后续统计总和）
			CwGyjfzcTj deleteMain = cwGyjfzcTjMapper.selectById(id);
			if (deleteMain == null) {
				throw new RuntimeException("待删除主表不存在，主表ID：" + id);
			}
			String unit = deleteMain.getUnit();
			String year = deleteMain.getYear();

			// 2. 删除当前主表的关联子表
			cwGyjfzcMapper.deleteByMainId(id);
			logger.debug("待删除主表关联子表删除完成，主表ID：{}", id);

			// 3. 重新统计【所有同年同单位】子表的总金额，更新CwJbszqkzb（关键修复：删后重新算总和）
			Map<FeeType, FeeAmount> totalFeeMap = calculateTotalFeeAmounts(unit, year);
			CwJbszqkzbZhu zhuEntity = getOrCreateJbszqkzbZhu(unit, year, getLoginUser().getId());
			saveOrUpdateJbszqkzb(unit, year, zhuEntity.getId(), getLoginUser().getId(), totalFeeMap, true);

			// 4. 删除主表
			cwGyjfzcTjMapper.deleteById(id);
			logger.info("公用经费支出提交表删除完成，主表ID：{}", id);
		} catch (Exception e) {
			logger.error("删除公用经费支出提交表失败，主表ID：{}", id, e);
			throw new RuntimeException("删除异常：" + e.getMessage(), e);
		}
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void delBatchMain(Collection<? extends Serializable> idList) {
		if (CollectionUtils.isEmpty(idList)) {
			logger.info("批量删除列表为空，无需处理");
			return;
		}
		logger.info("开始批量删除公用经费支出提交表，待删除记录数：{}", idList.size());

		// 存储批量删除涉及的【单位-年份】组合（避免重复统计）
		Map<String, String> unitYearMap = new java.util.HashMap<>();

		for (Serializable id : idList) {
			if (id == null) {
				logger.warn("批量删除存在空ID，跳过当前记录");
				continue;
			}
			String mainId = id.toString();
			try {
				// 1. 获取当前主表的单位和年份
				CwGyjfzcTj deleteMain = cwGyjfzcTjMapper.selectById(mainId);
				if (deleteMain == null) {
					logger.warn("待删除主表不存在，跳过当前记录，主表ID：{}", mainId);
					continue;
				}
				String unit = deleteMain.getUnit();
				String year = deleteMain.getYear();
				unitYearMap.put(unit, year); // 记录涉及的单位-年份

				// 2. 删除当前主表的关联子表
				cwGyjfzcMapper.deleteByMainId(mainId);
				// 3. 删除当前主表
				cwGyjfzcTjMapper.deleteById(id);
				logger.debug("批量删除成功，主表ID：{}", mainId);
			} catch (Exception e) {
				logger.error("批量删除失败，主表ID：{}", mainId, e);
				throw new RuntimeException("批量删除异常，异常ID：" + mainId + "，原因：" + e.getMessage(), e);
			}
		}

		// 4. 对每个涉及的【单位-年份】，重新统计总和并更新CwJbszqkzb（关键修复）
		LoginUser loginUser = getLoginUser();
		for (Map.Entry<String, String> entry : unitYearMap.entrySet()) {
			String unit = entry.getKey();
			String year = entry.getValue();
			Map<FeeType, FeeAmount> totalFeeMap = calculateTotalFeeAmounts(unit, year);
			CwJbszqkzbZhu zhuEntity = getOrCreateJbszqkzbZhu(unit, year, loginUser.getId());
			saveOrUpdateJbszqkzb(unit, year, zhuEntity.getId(), loginUser.getId(), totalFeeMap, true);
			logger.debug("批量删除后更新CwJbszqkzb完成，unit：{}，year：{}", unit, year);
		}

		logger.info("批量删除完成，共处理{}条记录，涉及{}个单位-年份组合", idList.size(), unitYearMap.size());
	}


	// ====================== 工具方法（修复核心：新增“全量统计总和”方法） ======================
	/**
	 * 获取当前登录用户（统一空指针处理）
	 */
	private LoginUser getLoginUser() {
		LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
		if (loginUser == null || loginUser.getId() == null || loginUser.getId().trim().isEmpty()) {
			throw new RuntimeException("登录状态失效，请重新登录后操作");
		}
		return loginUser;
	}

	/**
	 * 获取或创建收支明细总表主表（CwJbszqkzbZhu）
	 */
	private CwJbszqkzbZhu getOrCreateJbszqkzbZhu(String unit, String year, String userId) {
		// 校验入参
		if (unit == null || year == null) {
			throw new RuntimeException("单位（unit）或年份（year）为空，无法创建收支明细总表主表");
		}

		// 1. 先查询已有记录
		LambdaQueryWrapper<CwJbszqkzbZhu> wrapper = new LambdaQueryWrapper<>();
		wrapper.eq(CwJbszqkzbZhu::getUnit, unit)
				.eq(CwJbszqkzbZhu::getYear, year);

		CwJbszqkzbZhu zhuEntity = cwJbszqkzbZhuService.getOne(wrapper);
		if (zhuEntity != null) {
			logger.debug("查询到收支明细总表主表，unit：{}，year：{}，主表ID：{}", unit, year, zhuEntity.getId());
			return zhuEntity;
		}

		// 2. 无记录则创建新主表
		zhuEntity = new CwJbszqkzbZhu();
		zhuEntity.setUnit(unit);
		zhuEntity.setYear(year);
		zhuEntity.setMainId(userId);
		cwJbszqkzbZhuService.save(zhuEntity);
		logger.debug("创建收支明细总表主表成功，unit：{}，year：{}，新主表ID：{}", unit, year, zhuEntity.getId());
		return zhuEntity;
	}

	/**
	 * 仅插入当前主表的子表（拆分原calculateFeeAmounts的插入逻辑，避免单表统计）
	 */
	private void insertSubList(String mainId, List<CwGyjfzc> cwGyjfzcList) {
		if (CollectionUtils.isEmpty(cwGyjfzcList)) {
			logger.info("子表列表为空，无需执行插入");
			return;
		}

		for (CwGyjfzc entity : cwGyjfzcList) {
			entity.setMainId(mainId);

			// 设置支出类型（商品和服务支出/资本性支出）
			FeeType feeType = FeeType.getByFeeName(entity.getJjflkm());
			if (feeType != null) {
				entity.setDisbursementType(feeType.getDisbursementType());
			} else {
				logger.warn("非标准费用类型，未设置支出类型：{}（子表ID：{}）", entity.getJjflkm(), entity.getId());
			}

			cwGyjfzcMapper.insert(entity);
			logger.debug("子表插入成功，子表ID：{}，费用类型：{}，支出类型：{}",
					entity.getId(), entity.getJjflkm(), entity.getDisbursementType());
		}
		logger.info("子表插入完成，共插入{}条记录", cwGyjfzcList.size());
	}

	/**
	 * 统计【所有同年同单位】CwGyjfzc子表的金额总和（核心修复：替代单表统计）
	 * @param unit 单位
	 * @param year 年份
	 * @return 各费用类型的总金额
	 */
	private Map<FeeType, FeeAmount> calculateTotalFeeAmounts(String unit, String year) {
		// 校验入参
		if (unit == null || year == null) {
			throw new RuntimeException("单位（unit）或年份（year）为空，无法统计总金额");
		}

		// 1. 查询所有同年同单位的子表数据
		LambdaQueryWrapper<CwGyjfzc> wrapper = new LambdaQueryWrapper<>();
		// 关联主表的unit和year（假设CwGyjfzc有mainId关联CwGyjfzcTj，通过主表查单位年份）
		wrapper.inSql(CwGyjfzc::getMainId, "SELECT id FROM cw_gyjfzc_tj WHERE unit = '" + unit + "' AND year = '" + year + "'");
		List<CwGyjfzc> allSubList = cwGyjfzcMapper.selectList(wrapper);

		// 2. 初始化42种费用的统计容器
		Map<FeeType, FeeAmount> totalFeeMap = new EnumMap<>(FeeType.class);
		for (FeeType type : FeeType.values()) {
			totalFeeMap.put(type, new FeeAmount());
		}

		// 3. 累加所有子表的金额
		if (CollectionUtils.isNotEmpty(allSubList)) {
			for (CwGyjfzc sub : allSubList) {
				FeeType feeType = FeeType.getByFeeName(sub.getJjflkm());
				if (feeType == null) {
					logger.warn("非标准费用类型，跳过统计：{}（子表ID：{}）", sub.getJjflkm(), sub.getId());
					continue;
				}
				totalFeeMap.get(feeType).accumulate(sub.getFinancial(), sub.getMoney());
			}
			logger.info("总金额统计完成，unit：{}，year：{}，涉及子表数：{}", unit, year, allSubList.size());
		} else {
			logger.info("无同年同单位的子表数据，unit：{}，year：{}，返回空统计", unit, year);
		}

		return totalFeeMap;
	}

	/**
	 * 保存/更新收支明细子表（CwJbszqkzb），基于【所有子表总和】更新（核心修复）
	 * @param isUpdate true=更新主表操作，false=新增主表操作（仅控制日志，金额逻辑统一用总和）
	 */
	private void saveOrUpdateJbszqkzb(String unit, String year, String zhuId, String userId, Map<FeeType, FeeAmount> totalFeeMap, boolean isUpdate) {
		// 校验入参
		if (unit == null || year == null || zhuId == null || totalFeeMap == null) {
			throw new RuntimeException("单位（unit）、年份（year）、收支总表主ID（zhuId）或总金额统计（totalFeeMap）为空，无法处理收支明细子表");
		}

		// 循环处理42种费用的明细记录
		for (Map.Entry<FeeType, FeeAmount> entry : totalFeeMap.entrySet()) {
			FeeType feeType = entry.getKey();
			FeeAmount totalAmount = entry.getValue();

			// 构建查询条件：单位+年份+费用类型（唯一标识一条明细）
			LambdaQueryWrapper<CwJbszqkzb> queryWrapper = new LambdaQueryWrapper<>();
			queryWrapper.eq(CwJbszqkzb::getUnit, unit)
					.eq(CwJbszqkzb::getYear, year)
					.eq(CwJbszqkzb::getProject, feeType.getFeeName());

			CwJbszqkzb jbszqkzb = cwJbszqkzbService.getOne(queryWrapper);
			if (jbszqkzb == null) {
				// 1. 无旧数据：新增明细（含预算依据、填表说明）
				jbszqkzb = new CwJbszqkzb();
				jbszqkzb.setUnit(unit);
				jbszqkzb.setYear(year);
				jbszqkzb.setProject(feeType.getFeeName());
				jbszqkzb.setMainId(zhuId);
				jbszqkzb.setUserId(userId);
				jbszqkzb.setCwPx(feeType.getCwPx());
				jbszqkzb.setCalculationBasis(feeType.getCalculationBasis()); // 预算依据
				jbszqkzb.setCwTbsm(feeType.getCwTbsm()); // 填表说明
				jbszqkzb.setDisbursementType(feeType.getDisbursementType());
				logger.debug("{}操作：新增收支明细，费用类型：{}", isUpdate ? "更新主表" : "新增主表", feeType.getFeeName());
			} else {
				// 2. 有旧数据：仅更新金额（预算依据/填表说明保持枚举定义，不重复修改）
				logger.debug("{}操作：更新收支明细，费用类型：{}，明细ID：{}", isUpdate ? "更新主表" : "新增主表", feeType.getFeeName(), jbszqkzb.getId());
			}

			// 赋值总金额（财政金额、总金额、非财政金额）
			jbszqkzb.setFinancial(totalAmount.getFinancial());
			jbszqkzb.setYsshj(totalAmount.getMoney());
			jbszqkzb.setNonFinancials(totalAmount.getMoney() - totalAmount.getFinancial()); // 非财政=总-财政

			// 执行保存/更新
			cwJbszqkzbService.saveOrUpdate(jbszqkzb);
			logger.debug("收支明细处理完成，费用类型：{}，总金额：{}", feeType.getFeeName(), totalAmount.getMoney());
		}

		logger.info("所有收支明细处理完成，共覆盖{}种费用类型，unit：{}，year：{}", FeeType.values().length, unit, year);
	}
}
